import java.util.Arrays;
//java`操作的包，里面有很多的包
public class Test {


    //StringBuliding
    //以我们的知识储备，暂时看不懂高级的
    //
//    public static String myToString(int [] array){
//        String ret ="[";
//        for (int i = 0; i < array.length; i++) {
//            ret += array[i];
//            //这些通过一些小细节，就能够消除，作用。
//            if(i!=array.length-1) {
//                ret += ",";
//            }
//        }
//
//        ret +="]";
//        return ret;
//    }
        public static void main(String[]args){

            //冒泡排序：再次理解，


              //二分查找——必须是有序数组
              //二分查找
              //java里有

//              int []array={1,2,13,4,15};
//              Arrays.sort(array);//直接用人家的方法排序，
//              System.out.println(Arrays.toString(array));
//            System.out.println(Arrays.binarySearch(array,15));

            //面向对象的冰山一角
            //学会学习方法，
            //数组名，是首元素地址
              //有序之后，才会有二分的意义
              //因为有序，可以通过比较来每次砍掉一半，
              //速度加快
              //二分查找法
              //冒泡排序

            //二分查找速度秒杀
            //


//            int [] array={1,1,1,1,1,1};
//            int []copy = Arrays.copyOf(array,array.length*2);
//
//            System.arraycopy(array,0,copy,0,array.length);
//            //扩容，你把后面直接加长，扩容不就是，加长，然后放进去原有的东西，而且多了一些
//            //
//
//            System.out.println(Arrays.toString(copy));
//
//            int []copy2 = Arrays.copyOfRange(array,1,3);//左闭右开
//            //你把范围给的超过数组的小标，就是能拷贝多少拷贝多少
//            System.out.println(Arrays.toString(copy2));
            //数组的拷贝——for循环来进行拷贝，
            //java允许，用变量来给数组的长度。
//            int[] array = {1,2,3,4,5};
//            int []copy = new int [array.length];
//            for (int i = 0; i < array.length; i++) {
//                copy[i]=array[i];
//            }
//            System.out.println(Arrays.toString(copy));
                //以下代码是不是拷贝，
            //肯定不是，你把相同的东西存放在同一个地方，两个找到的是同一个地方
            //最起码有两份东西，

            //这不是拷贝
            //
            //两个路标指向同一个地方，但是地方就只有那么一个
            //六个人相互认识
            //每周会有一个分享会
            //分享会每个人都必须上台,讲一下自己学了什么？分享一些什么
            //评委——》
            //每周有一个晚上，玩游戏，
            //微信 淘米 游族 TCL 喜马拉雅 YY
            //微信的才是大佬，股票拿了50多万的股票，6-8个月的年终奖

            //当然，该跳槽的跳槽了

            //都是通过了努力，他们也曾想过放弃，但被其他人拉回来了

            //

            //每周去分享一些东西，开始的时候，可能是一坨屎

            //谁开始的时候，不是一坨屎，准备的不充分

            //算是备课之类的，
            //毕业时候，表达能力和知识也掌握了
            //

            //在整个学习中，肯定有懈怠，要互相督促

            //如果不是他，当时那么坚持的拉我去学习，我可能真的不回去干这个
            //去成为贵人吧
            //大大方方弄，黄就黄了
            //周分享。不要尴尬，不要怕
            //大家学就行了
            //我们当时学完之后，都自己整理了自己的文档
            //

            //各种东西都要靠自己，
            //我面试的时候，我把我的所有大学学的东西，都扔给面试官。

            //带着他上进，你看你还在那里装呢？还在那里学习
            //

            //运气和实力=7/3
            //


        //int []array={1,2,3,4,5};
        //System.out.println(myToString(array));
        //不要怕，软件是不会出现问题的，不行就重装

        //不要不小心把路径删除掉，这样太惨了
        //

        //电脑是中文的用户，——》电脑是中文的用户！
        //导致所有的东西都搞不了了
        //用户名是中文的，
        //软件是装不坏的，每次开机关机不敢开，不敢关，
        //现在再放回那个时候，能给电脑拆掉

        //java当中专门用来操作数组的，
        //int [] ret = func3();
        //String s = Arrays.toString();


//        int []array = {1,2,3,4};
//        int num=array.length;
//        //lenth求数组的长度，和sizeof类似的功能，但是计算大为不同
//        char []array1 = {'1','2','5'};
//        //String []array3 = "abcdef";
    }
    //借助工具——类

    //一直要扎扎实实，不能眼高手低，咋咋呼呼
    //我都会——你认为的会，可能达不到我认为的那种你认为的会
    //先是笔试，然后是面试。
    //


    //数组作为返回值，——但是java可以返回一组值
//    public static int []func3() {
//        int []array={1,2,3,4,5,6};
//        //返回类型是int[],和方法的返回类型就对应起来了
//
//        return array;
//    }
    //对象一定在堆上，引用对象却不一定在栈上。。

    //局部变量使用完后，被回收，但是对象还没用完，还在堆上
    //引用对象不一定实在栈上的

    //1.保存数据——变量肯定有这个作用
    //2.作为参数和作为返回值

//    public static void func1(int []array){
//        array = new int [10];
//    }
//    public static void func2(int []array){
//        array[0] = 99;
//    }

    //如果不对内存中存储的数据加以区分，那么管理起来就变得很难。我们的内存也需要去划分
    //内存划分是对java虚拟机的划分，也就是对jvm划分
    //总共划分为5块地方

    //方法区、虚拟机栈、本地方法栈
    //堆，程序计数器。

    //我们平时所说的栈，其实值得是java虚拟栈
    //局部变量存在虚拟机栈——JVM Stack
    //堆：一般是用来存储对象的——Heap
    //new创建的对象都是在这里的，
    //
    //每一块内存 都有自己的使命，
    //内存划分之后，特别好管理
    //

    //紫色代表线程隔离的数据区
    //蓝色代表线程共享的数据区

    //数据类型：
    //基本数据类型——4类，八种
    //引用数据类型——当前这个变量，里都是对象所在的地址
    //

    //给我的main方法开辟的栈帧，

    //局部变量，引用变量，是判断的依据不一样
    //堆区一般比栈区域大，

    //把array2的值给array1，其实是把引用给他。
    //并且原本的对象已经没有人能够找到他了，那么咋们的jvm会自动把他回收掉/
    //jvm会自动回收，并不需要程序员去自己free
    //当方法执行完之后，局部变量（也就是栈区）上面的被回收，

    //局部变量的生命周期和作用域是什么？？？

    //当对象没有人引用的时候，就会被自动回收

    //引用的指向到底是什么样子的？

    //java中的空类型——null
    //当我一个指针不知道指向什么地方的时候，我们放NULL

    //
    int [] array = null;
    //因为它什么都不指向，你没法求数组的长度
    //代表引用三这个引用，不指向任何对象！！！
    //异常的名字是：空指针异常
    //欸？Java里面不是没有指针吗？
    //为什么会提示空指针异常——是英文的翻译而已和指针不一样

    //空指针异常会伴随整个学习的过程，遇到这个错误，要去找那个引用是空的，不指向任何对象

    //Java中没有约定null和0地址有任何的联系

    //数组的应用场景

    public static int max(int a,int b){
        return a > b ? a:b ;
    }
    public static int max(int a,int b, int c){
        //此处利用了代码的复用，不要一味的重复
        int max = max(a,b);
        return max(max,c);
    }
    //方法名一样，参数列表不同，返回值不做要求

    //c语言实现汉诺塔——java实现汉诺塔

}
